Handling document revision history information in the presence of a multi-user permissions model

ABSTRACT

One embodiment of the present invention provides a system that controls accesses to revisions of documents in the presence of a multi-user permissions and ownership model. During operation, the system receives a request to on behalf of a user to access a revision of a document. If the request is directed to a most-recent revision of an existing document, the system uses the multi-user permissions and ownership model to control access to the revision. Otherwise, if the request is directed to a previous revision of the document, the system grants access to the revision only if the user was the owner of the document at the time of the revision.

RELATED APPLICATIONS

This application is a continuation of, and hereby claims priority under 35 U.S.C. §120 to pending U.S. patent application Ser. No. 11/731,662, titled “Handling Document Revision History Information in the Presence of a Multi-User Permissions Model,” filed 30 Mar. 2007.

BACKGROUND

1. Field of the Invention

The present invention relates to techniques for controlling access to data within computer systems. More specifically, the present invention relates to a method and an apparatus for handling document revision history information in the presence of a multi-user permissions and ownership model.

2. Related Art

File systems generally provide sophisticated mechanisms for enforcing access rights to files. These mechanisms control the ability users to perform specific operations on files. For example, UNIX-based file systems provide permission mechanisms which allow specific users (or groups of users) to selectively: read, write or execute individual files.

These file-system-based permission mechanisms are generally effective for controlling accesses to current versions of existing files. However, in many situations it is desirable to be able to access data from previous revisions of files, or from files that have been deleted from the file system. These types of accesses can be facilitated by caching previous revisions of files. However, when users view previous revisions of files, it is important to ensure that users cannot view revisions that they did not have permission to view originally. This cannot be accomplished by simply caching permissions for files because advanced operating systems provide other mechanisms, such as Access Control Lists (ACLs) and kernel plugins, to perform permissions checks. These other mechanisms can change their decisions on a minute-by-minute basis and cannot be cached.

Hence, what is needed is a method and an apparatus for controlling accesses to cached revisions of documents without violating permissions.

SUMMARY

One embodiment of the present invention provides a system that controls accesses to revisions of documents in the presence of a multi-user permissions and ownership model. During operation, the system receives a request to on behalf of a user to access a revision of a document. If the request is directed to a most-recent revision of an existing document, the system uses the multi-user permissions and ownership model to control access to the revision. Otherwise, if the request is directed to a previous revision of the document, the system grants access to the revision only if the user was the owner of the document at the time of the revision.

In some embodiments, the request is received from a query processor, which can return previous and most-recent revisions of documents while processing a query.

In some embodiments, prior to receiving the request to access the revision of the document, the system receives a query containing terms from the user. In response to this query, the system looks up the terms in previous and most-recent revisions of the documents. If the terms in the query match terms in a revision of a document, the system requests access to the matching revision on behalf of the user. If access is granted, the system presents the matching revision to the user.

In some embodiments, upon receiving an additional revision for a document, the system stores the additional revision in data structures that contain document history information to facilitate subsequently looking up the additional revision.

In some embodiments, the additional revision is stored along with an identifier for the owner of the document at the time of the additional revision.

In some embodiments, the document comprises a sequence of events, wherein each event can be associated with a revision.

In some embodiments, a revision of the document can be: an initial version of the document; the most-recent revision of the document; or any other revision of the document.

In some embodiments, the permissions and ownership model is part of a file system which stores files containing documents, wherein each file in the file system is associated with an owner and a set of permissions.

In some embodiments, using the permissions and ownership model to control access to the revision involves examining permissions within the file system and also involves using one or more authorization modules, access control lists or plug-ins to authorize access to the revision.

BRIEF DESCRIPTION OF THE FIGURES

FIG. 1 illustrates a system that supports searching through cache revisions of documents in accordance with an embodiment of the present invention.

FIG. 2 illustrates a data structure for an event in accordance with an embodiment of the present invention.

FIG. 3 illustrates a data structure for a document in accordance with an embodiment of the present invention.

FIG. 4A illustrates a data structure for a document which includes one event in accordance with an embodiment of the present invention.

FIG. 4B illustrates a data structure for a document which includes two events in accordance with an embodiment of the present invention.

FIG. 4C illustrates a data structure for a document which includes three events in accordance with an embodiment of the present invention.

FIG. 4D illustrates a data structure for a document which includes four events in accordance with an embodiment of the present invention.

FIG. 5 presents a flow chart illustrating the process of performing a query on document revisions in accordance with an embodiment of the present invention.

FIG. 6 presents a flow chart illustrating the process of controlling an access to a revision of a document in accordance with an embodiment of the present invention.

FIG. 7 presents a flow chart illustrating the process of storing an additional event for a document in accordance with an embodiment of the present invention.

DETAILED DESCRIPTION

The following description is presented to enable any person skilled in the art to make and use the disclosed embodiments, and is provided in the context of a particular application and its requirements. Various modifications to the disclosed embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other embodiments and applications without departing from the spirit and scope of the present description. Thus, the present description is not intended to be limited to the embodiments shown, but is to be accorded the widest scope consistent with the principles and features disclosed herein.

The data structures and code described in this detailed description are typically stored on a computer-readable storage medium, which may be any device or medium that can store code and/or data for use by a computer system. This includes, but is not limited to, volatile memory, non-volatile memory, magnetic and optical storage devices such as disk drives, magnetic tape, CDs (compact discs), DVDs (digital versatile discs or digital video discs), or other media capable of storing computer readable media now known or later developed.

Rules for Handling Permissions

A major complication in designing a system that handles revisions is that in sophisticated operating systems we cannot cache permissions for past revisions, or for files that no longer exist on disk (for the reasons stated above). In order to solve this problem, one embodiment of the present invention uses the simple rule that only the owner of the file at the time of the revision (which is easy to cache and cannot be affected by ACLs or kernel authorization plugins) can see past revisions of the file, otherwise we defer to the existing file system permissions for the most-recent revisions of files.

This rule has a number of consequences. (1) A user who has never owned a document, but has read permissions for the on-disk file, can only see the most-recent revision of the file and not any previous revisions. (2) A user who previously owned a document can only see revisions from the time period that they owned the document, plus the current revision if they have read permission to the on-disk file. (3) The owner of the file cannot see revisions of documents before they became the owner, regardless of the previous file permissions. (4) Also, once a file has been deleted from disk, only past owners can see revisions, and again, only the revisions from the time period they owned the file.

EXAMPLES

We now describe how one embodiment of the present invention uses the above-described rule to handle a number of different situations. In the examples which follow, we assume there are at least two users on a machine, user A and user B. We also assume that the machine supports the UNIX™ permissions model, wherein files have both an “owner” and a set of permissions (owner/group/other), which allows permissions to be granted to users who are not the owner of a file.

Suppose user A creates a document in the file system and user B does not have permission to read it. In this case, we need to ensure that user B cannot see the most-recent revision of the file when browsing document history. Because we are dealing with the most-recent revision of a file, we defer to the UNIX file permissions, so user B does not have read permission to the on-disk file.

In another example, suppose user A creates a document and user B has permission to read it. In this case, we need to ensure that user B sees the most-recent revision of the file when browsing through the document history. Because we are again dealing with the most-recent revision of a file, we similarly defer to the UNIX file permissions, so user B has read permission and is able to see the most-recent revision.

Now suppose user A revises a document that user B can read and suppose that the document is still available on disk. In this case, user B can see the most-recent revision of the file (as above), but what about a previous revision? We cannot simply cache permissions at that the time of the previous revision, because advanced operating systems provide mechanisms, such as Access Control Lists (ACLs) and kernel plugins, which are called during permissions checks. These mechanisms can change their decisions on a minute-by-minute basis and can base their determinations on state information that cannot be cached. In this case, user B can see the most-recent revision, but since there is no way to “go back in time” to the time just before user A made the revision to check permissions, and because we cannot cache permissions, we allow past revisions to only be viewed by the owner at the time of the revisions, which is user A. Therefore, user B cannot see the past revision for which user A was the owner (even if user B had permission to access the file at the time of the revision).

In another example, suppose user A deletes a document that user B could read. In this case, we cannot determine who has permission to read the previous revisions because the file is no longer on disk and we consequently cannot use on-disk permission information to check authorization. Furthermore, we cannot go back in time to check the permissions before user A deleted the file, nor can we cache permissions. Hence, in this case only user A may see the revisions once the file has been deleted (with the exception of past revisions where user B was the file owner, see below).

In yet another example, suppose user A creates a document, and then revises the document a few times before changing the ownership of the document to user B. At some point, the ownership may even be transferred back to user A. Which revisions can each user see in the history? In this case, past revisions are only available to the owner of the document at the time, so user A can see the revisions for the time periods where user A owned the document, and User B can see the revisions for the time periods where user B owned the document.

Purging a Document

One embodiment of the present invention enables users to purge a document from the system. Purging involves fully removing revisions from the repository and database, and can be done for an individual revision or for the document as a whole (which deletes all events). Additionally, when a document is purged, no further events are collected for this document even if the document still exists on disk and is being modified. Purging a document is forever.

One embodiment of the present invention provides the following rules to govern who is allowed to purge the revision history. (1) The owner of the file (or the owner of the most-recent revision if the file was deleted on disk) can purge the entire document history. Even if the history contains revisions owned by others, the current owner has ultimate power to remove all revisions even though they cannot see them (as above). (2) A user who is not the owner of the file cannot remove any previous revision, even ones for which the user was the owner of the file. In practice, rule (2) could be changed to allow owners of previous revisions to purge them separately, but this complicates the user experience for very little gain.

We now describe how to implement a system that implements the above-described rules.

Search System

FIG. 1 illustrates a system that supports searching through cached revisions of documents in accordance with an embodiment of the present invention. To support this searching, the system can perform a number of processes, including: crawling, ranking, searching and permissions-checking processes. During the crawling process, a crawler 104 crawls or otherwise searches through desktop computer 102 to find documents and/or revisions of documents to be stored in indexed form in a store for cached revision information 107. The selected revisions are then compressed, indexed and ranked by compressing, indexing, and ranking module 105 before being stored within store 107 (shown as store for cached revised information 107).

During a subsequent search process, a desktop search engine 112 receives a query 113 from a user 111 through a user interface (UI) 114. For example, UI 114 can be a query box that appears on a screen for desktop computer 102. The entered query 113 specifies a number of terms to be searched for in the set of revisions. In response to query 113, desktop search engine 112 uses terms in the query to identify highly-ranked documents and revisions that contain the terms. Search engine 112 then returns a response 115 through UI 114, wherein the response 115 identifies matching documents/revisions along with ranking information and provides references to the identified documents/revisions.

In one embodiment of the present invention, the store for cached revision information 107 contains: a full-text index 108, an event database 109 and a repository 110. Event database 109 stores metadata for indexable “events,” wherein each event can be associated with a revision. Full-text index 108 contains a reverse index which allows revisions to be looked up based on terms contained in the revisions. For example, in one embodiment of the present invention full-text index 108 maps tokenized terms to a posting list of event identifiers for revisions that contain the terms. These event identifiers are used to key into the event database 109, which stores non-content attributes about the events. Note that metadata from event database 109 can be used to tie together references to events from full-text index 108 and associated text from repository 110. Repository 110 stores the text content of files and/or revisions that have been indexed. (It can also store other document-related assets, such as thumbnails or favicons.)

One embodiment of the present invention represents documents as a sequence of revisions starting from an initial version of the document, wherein the revisions are represented as events. More specifically, FIG. 2 illustrates an exemplary data structure for an event 200 in accordance with an embodiment of the present invention. As illustrated in FIG. 2, event data structure 200 includes an event identifier 202, which is a globally unique identifier for the event. It also includes a file path 204 which identifies a file associated with the event. Event data structure 200 also includes an owner ID 206, which identifies the owner for the event and a document revision number 208, which specifies which revision of the file the event is associated with.

As mentioned above, each document is represented as a sequence of events. More specifically, FIG. 3 illustrates an exemplary data structure for a document 300 in accordance with an embodiment of the present invention. This data structure includes a document identifier 302, which uniquely identifies the document and also a file path 304, which specifies the location for the file. The data structure for document 300 also includes a deleted flag 306 which specifies whether the document has been deleted. It also includes a list of events 308, wherein the events in the list are associated the revisions. (Note that data structures for documents and events can be stored within event database 109 illustrated in FIG. 1).

FIGS. 4A-4C illustrate how a document 400 is comprised of a sequence of events. More specifically, FIG. 4A illustrates an initial version of a document, which includes a create event 402. For example, this document can be created with the command “$echo hi>foo.txt”, where “foo.txt” is the name of the document. Next, the document can be modified by using the command “$ echo bye>foo.txt”, which adds the modify event 404 to document 400 as is illustrated in FIG. 4B. The document is then renamed by using the command “$ mv foo.txt bar.txt”, which adds the rename event 406 to document 400 as is illustrated in FIG. 4C. Finally, the document is deleted by using the command “$ rm bar.txt”, which adds the delete event 408 to document 400 as is illustrated in FIG. 4C. (Alternatively, in one embodiment of the present invention, the delete command simply sets the deleted flag 306 for the document 300 instead of adding an additional event to the list of events 308 for document 300.)

Performing a Query

FIG. 5 presents a flow chart illustrating the process of performing a query on document revisions in accordance with an embodiment of the present invention. During this process, the system first receives a query containing terms from the user (step 502). Next, while processing the query, the system looks up the terms in full-text index 108 (step 504), which contains previous and most-recent revisions of the documents. This produces list of matching revisions (if there are any) (step 506). Next, the system requests access to the matching revisions on behalf of the user (step 508). The system then presents the matching revisions for which access has been granted to the user (step 510).

Controlling Access to a Revision

FIG. 6 presents a flow chart illustrating the process of controlling an access to a revision of a document in accordance with an embodiment of the present invention. During this process, the system first receives a request on behalf of a user to access a revision of a document (step 602). (Note that this request can occur during while processing a query for the user as is discussed above.) If the request is directed to the most-recent revision of an existing document, the system uses the existing multi-user permissions and ownership model of the file system to control access to the revision (step 604). Otherwise, if the document is deleted or the request is directed to a previous revision of the document, the system grants access to the revision only if the user was the owner of the document at the time of the revision (step 606). Note that this is a conservative restriction, which may prevent some users from accessing revisions that they could have accessed at the time the revisions where made.

However, as noted above, it is not possible to simply cache historic permissions because advanced operating systems often use sophisticated permissions-checking mechanisms, such as ACLs and kernel plug-ins. Hence, it is not possible to perform all of the permission checks that could have been performed at the time of the revision. The owner of the file at the time of the revision was certainly able to access the revision at the time the revision was made, which means that the permissions that existed at the time of the revision will not be violated by allowing the owner of the file at the time of the revision to access the file. Moreover, it is a simple matter to keep track of the owner of the file at the time of the revision by recording an owner ID 206 in each event 200 data structure.

For example, referring to FIG. 7, an owner ID can be recorded in an event as follows. When the system receives additional event (revision) to be added to document (step 702), the system first creates an event data structure 200 for the event (step 704). The system then records an identifier for the owner of the associated document in the event 200 data structure (step 706). The system also includes the event in the list of events 308 in the associated document 300 data structure (step 708).

The foregoing descriptions of embodiments have been presented for purposes of illustration and description only. They are not intended to be exhaustive or to limit the present description to the forms disclosed. Accordingly, many modifications and variations will be apparent to practitioners skilled in the art. Additionally, the above disclosure is not intended to limit the present description. The scope of the present description is defined by the appended claims. 

What is claimed is:
 1. A method for controlling access to revisions of documents, comprising: in one or more computers, performing operations for: receiving, on behalf of a user, a request to access a previous revision of a document that was made before a most-recent revision, wherein information indicating an owner of the document at a time that the previous revision was made is available, but a set of permissions for the document at the time that the previous revision was made is not available; granting access to the previous revision when the user was the owner of the document at the time that the previous revision was made; and granting access to the most-recent revision when the user was not the owner of the document at the time that the previous revision was made and when the user has read permissions for the document.
 2. The method of claim 1, wherein the method further comprises: in the one or more computers, performing operations for: receiving a query containing terms from the user; looking up the terms in previous revisions of documents; when the terms match terms in a given previous revision of a document, requesting to access the given previous revision on behalf of the user; and when access is granted to the given previous revision, presenting the given previous revision to the user.
 3. The method of claim 1, wherein the method further comprises: in the one or more computers, performing operations for: receiving an additional revision for a document; and storing information about the additional revision in at least one data structure that represents the document.
 4. The method of claim 3, wherein storing the information about additional revision in the at least one data structure comprises: storing information indicating an owner of the document at a time that the additional revision was made in the at least one data structure.
 5. The method of claim 1, wherein the method further comprises: in the one or more computer systems, performing operations for: for each document in a plurality of documents, maintaining a data structure that represents each of the documents, wherein the data structure that represents each document comprises a sequence of events, wherein each event is associated with a revision.
 6. The method of claim 1, wherein information indicating permissions for the most-recent revision of the document is available in a set of permissions for the document, and wherein the method further comprises: in the one or more computer systems, performing operations for: determining that the user was the owner of the document at the time that the previous revision was made using the information indicating the owner of the document at the time that the previous revision was made; and determining that the user has read permissions for the document using the set of permissions for the document.
 7. The method of claim 6, wherein the method further comprises: in the one or more computer systems, performing operations for: maintaining, in accordance with a multi-user permissions and ownership model: the information indicating the owner of the document at the time that the previous revision was made; and the set of permissions for the document.
 8. A non-transitory computer-readable storage medium storing instructions that, when executed by a computer, cause the computer to perform operations for controlling access to revisions of documents, the operations comprising: receiving, on behalf of a user, a request to access a previous revision of a document that was made before a most-recent revision, wherein information indicating an owner of the document at a time that the previous revision was made is available, but a set of permissions for the document at the time that the previous revision was made is not available; granting access to the previous revision when the user was the owner of the document at the time that the previous revision was made; and granting access to the most-recent revision when the user was not the owner of the document at the time that the previous revision was made and when the user has read permissions for the document.
 9. The computer-readable storage medium of claim 8, wherein the operations further comprise: receiving a query containing terms from the user; looking up the terms in previous revisions of documents; when the terms match terms in a given previous revision of a document, requesting to access the given previous revision on behalf of the user; and when access is granted to the given previous revision, presenting the given previous revision to the user.
 10. The computer-readable storage medium of claim 8, wherein the operations further comprise: receiving an additional revision for a document; and storing information about the additional revision in at least one data structure that represents the document.
 11. The computer-readable storage medium of claim 10, wherein storing the information about additional revision in the at least one data structure comprises: storing information indicating an owner of the document at a time that the additional revision was made in the at least one data structure.
 12. The computer-readable storage medium of claim 8, wherein the operations further comprise: for each document in a plurality of documents, maintaining a data structure that represents each of the documents, wherein the data structure that represents each document comprises a sequence of events, wherein each event is associated with a revision.
 13. The computer-readable storage medium of claim 8, wherein information indicating permissions for the most-recent revision of the document is available in a set of permissions for the document, and wherein the operations further comprise: determining that the user was the owner of the document at the time that the previous revision was made using the information indicating the owner of the document at the time that the previous revision was made; and determining that the user has read permissions for the document using the set of permissions for the document.
 14. The computer-readable storage medium of claim 13, wherein the operations further comprise: maintaining, in accordance with a multi-user permissions and ownership model: the information indicating the owner of the document at the time that the previous revision was made; and the set of permissions for the document.
 15. An apparatus for controlling access to revisions of documents, comprising: at least one computer, wherein the at least one computer is configured to perform operations for: receiving, on behalf of a user, a request to access a previous revision of a document that was made before a most-recent revision, wherein information indicating an owner of the document at a time that the previous revision was made is available, but a set of permissions for the document at the time that the previous revision was made is not available; granting access to the previous revision when the user was the owner of the document at the time that the previous revision was made; and granting access to the most-recent revision when the user was not the owner of the document at the time that the previous revision was made and when the user has read permissions for the document.
 16. The apparatus of claim 15, wherein the at least one computer is configured to perform operations for: receiving a query containing terms from the user; looking up the terms in previous revisions of documents; when the terms match terms in a given previous revision of a document, requesting to access the given previous revision on behalf of the user; and when access is granted to the given previous revision, presenting the given previous revision to the user.
 17. The apparatus of claim 15, wherein the at least one computer is configured to perform operations for: receiving an additional revision for a document; and storing information about the additional revision in at least one data structure that represents the document.
 18. The apparatus of claim 17, wherein, when storing the information about additional revision in the at least one data structure, the at least one computer is configured to perform operations for: storing information indicating an owner of the document at a time that the additional revision was made in the at least one data structure.
 19. The apparatus of claim 15, wherein the at least one computer is configured to perform operations for: for each document in a plurality of documents, maintaining a data structure that represents each of the documents, wherein the data structure that represents each document comprises a sequence of events, wherein each event is associated with a revision.
 20. The apparatus of claim 15, wherein information indicating permissions for the most-recent revision of the document is available in a set of permissions for the document, and wherein the at least one computer is configured to perform operations for: determining that the user was the owner of the document at the time that the previous revision was made using the information indicating the owner of the document at the time that the previous revision was made; and determining that the user has read permissions for the document using the set of permissions for the document.
 21. The apparatus of claim 20, wherein the at least one computer is configured to perform operations for: maintaining, in accordance with a multi-user permissions and ownership model: the information indicating the owner of the document at the time that the previous revision was made; and the set of permissions for the document. 